mod account_logger;
mod config;
mod config_watcher;
mod day_counter;
mod doc_generator;
mod execution_tracker;
mod http_client;
mod proxy_checker;
mod scheduler_new;
mod task_manager;
mod tasks;
mod utils;

use std::env;
use config::Config;
use log::{error, info};
use scheduler_new::AdvancedScheduler;
use proxy_checker::ProxyChecker;
use doc_generator::{DocGenerator, DocFormat};

#[tokio::main]
async fn main() {
    // 检查是否是自动重启
    let args: Vec<String> = env::args().collect();
    
    // 检查是否是文档生成命令
    if args.iter().any(|arg| arg == "--generate-docs" || arg == "--gen-docs") {
        generate_documentation(&args).await;
        return;
    }
    
    let is_auto_restart = args.iter().any(|arg| arg == "--auto-restart");
    
    if is_auto_restart {
        // 自动重启模式,循环运行
        run_with_auto_restart().await;
    } else {
        // 普通模式,运行一次
        run_once().await;
    }
}

/// 带自动重启的运行模式
async fn run_with_auto_restart() {
    // 初始化日志(只初始化一次)
    env_logger::Builder::from_default_env()
        .filter_level(log::LevelFilter::Info)
        .init();
    
    let mut restart_count = 0;
    
    loop {
        if restart_count > 0 {
            info!("");
            info!("========================================");
            info!("第 {} 次重启", restart_count);
            info!("========================================");
            info!("");
        }
        
        let exit_code = run_once_internal().await;
        
        match exit_code {
            0 => {
                // 正常退出
                info!("✅ 程序正常退出");
                break;
            }
            100 => {
                // 配置变更,需要重启
                info!("🔄 检测到配置变更,准备重启...");
                tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
                restart_count += 1;
            }
            _ => {
                // 异常退出
                error!("❌ 程序异常退出,退出码: {}", exit_code);
                info!("等待5秒后重启...");
                tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
                restart_count += 1;
            }
        }
    }
}

/// 运行一次(普通模式入口)
async fn run_once() -> i32 {
    // 初始化日志
    env_logger::Builder::from_default_env()
        .filter_level(log::LevelFilter::Info)
        .init();
    
    run_once_internal().await
}

/// 运行一次的内部实现,返回退出码
async fn run_once_internal() -> i32 {
    
    // 读取命令行参数
    let args: Vec<String> = env::args().collect();
    let mut config_path = "config.toml".to_string(); // 默认路径

    if let Some(pos) = args.iter().position(|x| x == "--config")
        && let Some(path) = args.get(pos + 1)
    {
        config_path = path.clone();
    }

    // 加载配置
    let mut config = match Config::from_file(&config_path) {
        Ok(config) => config,
        Err(e) => {
            error!("加载配置文件失败: {}", e);
            return 1;
        }
    };

    // 验证配置
    if let Err(e) = config.validate() {
        error!("配置验证失败: {}", e);
        return 1;
    }

    let enabled_tasks = config.get_enabled_tasks();
    info!("启用的任务: {:?}", enabled_tasks);

    if enabled_tasks.is_empty() {
        info!("没有启用的任务");
        return 0;
    }

    // 检测代理可用性（如果配置了代理）
    let check_proxy = !args.iter().any(|arg| arg == "--skip-proxy-check");
    if check_proxy {
        check_proxies(&config).await;
    }

    // 根据配置选择执行模式
    info!("当前执行模式: {}", config.schedule.mode);

    let mut scheduler = AdvancedScheduler::new();
    scheduler.set_config_path(config_path.clone());
    scheduler.run(&config).await
}

/// 检测所有代理的可用性
async fn check_proxies(config: &Config) {
    let checker = ProxyChecker::new(10); // 10秒超时
    let results = checker.check_all_proxies(config).await;
    
    // 如果有不可用的代理，给出警告
    let unavailable: Vec<_> = results.iter()
        .filter(|(_, r)| !r.is_available)
        .collect();
    
    if !unavailable.is_empty() {
        info!("⚠️  警告: 检测到 {} 个不可用的代理", unavailable.len());
        info!("   程序将继续运行，但使用不可用代理的账号可能会失败");
        info!("");
    }
}

/// 生成项目文档
async fn generate_documentation(args: &[String]) {
    // 初始化日志
    env_logger::Builder::from_default_env()
        .filter_level(log::LevelFilter::Info)
        .init();
    
    info!("📚 Task Execute Scheduler - 文档生成工具");
    info!("");
    
    let generator = DocGenerator::new();
    
    // 检查依赖
    if let Err(e) = generator.check_and_install_dependencies() {
        error!("❌ {}", e);
        return;
    }
    
    // 确定生成格式
    let format = if args.iter().any(|arg| arg == "--html") {
        DocFormat::Html
    } else if args.iter().any(|arg| arg == "--markdown" || arg == "--md") {
        DocFormat::Markdown
    } else {
        DocFormat::Both // 默认生成两种格式
    };
    
    // 生成文档
    match generator.generate_docs(format) {
        Ok(files) => {
            info!("✅ 成功生成以下文档:");
            for file in files {
                info!("   📄 {}", file);
            }
            info!("");
            info!("提示: HTML文档可以在浏览器中打开，按Ctrl+P可以打印为PDF");
        }
        Err(e) => {
            error!("❌ 文档生成失败: {}", e);
        }
    }
}
